#include<iostream>
#include<string>
#include<vector>
#include<thread>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>

void threadrun(std::string name,int num)
{
    while(num)
    {
        std::cout << name << " num : " << num << std::endl;
        num--;
        sleep(1);
    }
}

int main()
{
    std::string name = "thread-1";
    std::thread mythread(threadrun,name,10);

    while(true)
    {
        std::cout << "main thread..." << std::endl;
        sleep(1);
    }
    mythread.join();

    return 0;
}

// // class ThreadData
// // {
// // public:
// //     int Excute()
// //     {
// //         return _x +_y;
// //     }
// // public:
// //     std::string _name;
// //     int _x;
// //     int _y;  
// //     //other
// // };

// // class ThreadResult
// // {
// // public:
// //     std::string print()
// //     {
// //        return std::to_string(_x) + "+" + std::to_string(_y) + "=" + std::to_string(_result);
// //     }
// // public:
// //     int _x;
// //     int _y;
// //     int _result;
// // };

// // void* threadRun(void* args)
// // {
// //     ThreadData* td = static_cast<ThreadData*>(args);
// //     ThreadResult* result = new ThreadResult();
// //     int cnt = 10;
// //     while(cnt)
// //     {
// //         sleep(1); 
// //         std::cout<< td->_name << " run ... " << ",cnt : " << cnt-- << std::endl;
// //         result->_result = td->Excute();
// //         result->_x = td->_x;
// //         result->_y = td->_y;
// //         break;
// //         // int* p = nullptr;
// //         // *p = 100;
        
// //     }
// //     delete td;
// //     return (void*)result;
// // }
// std::string PrintToHex(pthread_t& tid)
// {
//     char buffer[64];
//     snprintf(buffer,sizeof(buffer),"0x%lx",tid);
//     return buffer;
// }

// const int num = 10;

// void* threadrun(void* args)
// {
//     //pthread_detach(pthread_self());//和main thread分离
//     std::string name = static_cast<const char*>(args);
//     while(true)
//     {
//         std::cout << name << " is running..." << std::endl;
//         sleep(3);
//         break;
//     }
//     // return args;
//     pthread_exit(args);//专门用来终止一个线程的
//     // exit(1);
// }

// int main()
// {
//     std::vector<pthread_t> tids;
//     for(int i = 0 ; i < num ; i++)
//     {
//         //1.有线程的id
//         pthread_t tid;
//         //2.有线程的名字
//         char* name = new char[128];
//         snprintf(name,128,"thread-%d",i+1);
//         pthread_create(&tid,nullptr,threadrun,/*线程名字*/name);

//         //3.保存所有线程的id信息
//         tids.emplace_back(tid);
//     }

//     for(auto tid : tids)
//     {
//         pthread_detach(tid);
//     }

//     while(true)
//     {
//         sleep(1);
//     }

//     // sleep(5);
//     // //join to to
//     // for(auto tid : tids)
//     // {
//     //     // pthread_cancel(tid);
//     //     // std::cout << "cancel: " << PrintToHex(tid) << std::endl;
//     //     // std::cout << PrintToHex(tid) << " quit..." << std::endl;
//     //     void* result = nullptr;
//     //     int n = pthread_join(tid,&result); 
//     //     std::cout << (long long int)result << " quit...,n : " << n << std::endl;
//     //     // delete (const char*)result;
//     // }

//     // sleep(100); 

//     // pthread_t tid;//unsigned long int
//     // //问题1.main和new线程谁先运行呢？不确定 
//     // ThreadData* td = new ThreadData();
//     // td->_x = 10;
//     // td->_y = 20;

//     // int n = pthread_create(&tid,nullptr,threadRun,(void*)td);
//     // if(n != 0)
//     // {
//     //     std::cerr << "create thread error" << std::endl;
//     //     return 1;
//     // }
//     // std::string tid_str = PrintToHex(tid);//按照16进制打印出来
//     // std::cout << "tid : " << tid_str << std::endl;
//     // std::cout << "main thread join begin..." << std::endl;
//     // //2.我们期望谁最后退出？main thread ，如何保证？
//     // ThreadResult* result = nullptr;
//     // n = pthread_join(tid,(void**)&result);//join来保证
//     // if(n == 0)
//     // {
//     //     std::cout << "main thread wait success,new thread exit code : " << result->print() << std::endl;
//     // }

//     // sleep(100);
//     return 0;
// }